Git is a distributed version control system used to track changes in source code, maintain project history, create branches, collaborate with other developers, and safely manage different versions of a software project. Git allows developers to work locally while maintaining a complete history of project changes.
GitHub is a cloud-based platform built around Git that provides remote repositories and collaboration features such as pull requests, code reviews, issues, project discussions, and repository management. Git and GitHub are commonly used together in modern software development and automation projects. :contentReference[oaicite:0]{index=0}
For Selenium automation engineers, Git and GitHub are especially important because automation frameworks usually contain many test classes, Page Object classes, configuration files, test data files, utilities, reports, and CI/CD configuration. Version control makes it easier to track, review, share, and restore these project changes.
Course Resource: Selenium Training | Register for Course Demo
Git is a distributed version control system that records changes made to files over time. It allows developers to create snapshots of a project, compare changes, restore previous versions, work on separate branches, and combine work from multiple developers.
Because Git is distributed, developers normally have a complete local repository containing the project's history, branches, and files rather than depending entirely on a central server. :contentReference[oaicite:1]{index=1}
Project
|
+-- LoginTest.java
+-- SearchTest.java
+-- LoginPage.java
+-- ConfigReader.java
|
v
Git Repository
|
+-- Commit 1
+-- Commit 2
+-- Commit 3
+-- Commit 4
GitHub is a hosting and collaboration platform for Git repositories. A local Git repository can be connected to a remote repository on GitHub so developers can publish commits, collaborate with teammates, review changes, and manage project work.
GitHub supports collaboration through repositories, branches, pull requests, code reviews, issues, and other development tools. :contentReference[oaicite:2]{index=2}
| Git | GitHub |
|---|---|
| Version control system | Platform for hosting and collaboration |
| Runs locally | Primarily provides remote/cloud collaboration |
| Tracks project history | Hosts Git repositories |
| Uses commands such as git commit | Provides repository and collaboration interfaces |
| Can work without GitHub | Uses Git as its core version-control system |
| Manages local branches and commits | Supports remote repositories, pull requests, reviews, and collaboration |
Git is an important skill for Selenium automation engineers because automation projects are continuously modified as new test cases, page objects, utilities, browsers, environments, and reporting features are added.
A Version Control System (VCS) records changes to files so that previous versions can be inspected or restored. Instead of manually creating folders such as project-final, project-final-new, and project-final-latest, Git maintains a structured history of changes.
Project_Final
Project_Final_New
Project_Final_New_Updated
Project_Final_Updated_2
Project_Final_Final
Repository
|
+-- Commit A
+-- Commit B
+-- Commit C
+-- Commit D
Git is distributed, meaning each cloned repository contains the files and repository history needed for local version-control operations. Developers can create commits, branches, and inspect history locally, then synchronize with a remote repository when required.
Developer A
|
v
Local Git Repository
|
+--------------------+
|
v
GitHub Repository
^
|
+--------------------+
|
v
Developer B
Local Git Repository
A Git repository is a project directory tracked by Git. It contains the project files and Git's internal repository information, including commit history and branch information.
A repository can exist locally on a developer's computer and can also be associated with a remote repository such as GitHub.
One of the most important concepts in Git is understanding the movement of changes between the working directory, staging area, and repository.
Working Directory
|
| git add
v
Staging Area
|
| git commit
v
Local Repository
|
| git push
v
Remote Repository
The working directory contains the files currently being edited.
The staging area contains changes selected for the next commit.
The local repository contains committed project history.
The remote repository is a repository hosted on a remote service such as GitHub.
Git must be installed on the computer before Git commands can be used from the command line. Installation steps depend on the operating system.
After installation, verify Git using:
git --versionExample output:
git version 2.x.xGit uses a configured username to associate commits with an author identity.
git config --global user.name "Your Name"To verify the configuration:
git config --global user.nameAn email address can also be configured for Git commit identity.
git config --global user.email "[email protected]"To verify:
git config --global user.emailGit's tutorial documentation also recommends configuring a name and email before performing normal Git operations. :contentReference[oaicite:3]{index=3}
To display Git configuration values:
git config --listYou can also inspect a specific value:
git config --global user.name
git config --global user.email
The git init command initializes a new Git repository in an existing project directory.
git initAfter initialization, Git creates its internal repository data under the .git directory.
Existing Project
|
| git init
v
Git Repository
mkdir selenium-project
cd selenium-project
git init
Now the directory is ready to be managed by Git.
The git status command shows the current state of the working directory and staging area.
git statusIt can show information such as untracked files, modified files, and staged changes. GitHub's documentation identifies git status as a basic command for viewing changes as untracked, modified, or staged. :contentReference[oaicite:4]{index=4}
Suppose a Selenium project contains the following file:
LoginTest.javaAfter creating or modifying the file, run:
git statusGit may identify the file as untracked if it has not yet been added to version control.
The git add command stages changes for the next commit.
git add LoginTest.javaTo stage all suitable changes in the current directory:
git add .Staging allows the developer to select exactly which changes should become part of the next snapshot. :contentReference[oaicite:5]{index=5}
The staging area is an intermediate area between the working directory and the repository.
File Modified
|
v
git add
|
v
Staging Area
|
v
git commit
|
v
Repository
This separation gives developers control over which changes are included in a commit.
The git commit command creates a snapshot of staged changes in the local repository.
git commit -m "Add login automation test"A commit should have a meaningful message describing the change.
git commit -m "Add login page object"
git commit -m "Add checkout test cases"
git commit -m "Fix login locator"
git commit -m "Update browser configuration"
A commit acts as a saved snapshot in the project's history. :contentReference[oaicite:6]{index=6}
Edit Files
|
v
git status
|
v
git add
|
v
git commit
|
v
Local History
The git log command displays commit history.
git logA compact version can be displayed using:
git log --onelinea31f2c1 Add checkout automation
b52e8d2 Fix login locator
c73a912 Add search page
d84f021 Initial framework
The git diff command can be used to inspect changes that have not yet been staged.
git diffThis is useful for reviewing code before staging or committing it.
A branch is an independent line of development. Branches allow developers to work on features or fixes without directly changing another branch.
main
|
+-- feature-login
|
+-- feature-search
|
+-- bugfix-checkout
Branches are lightweight in Git and are commonly used to isolate work before changes are merged into a main development line. :contentReference[oaicite:7]{index=7}
To list local branches:
git branchTo create a new branch:
git branch login-featureModern Git provides the git switch command for changing branches.
git switch login-featureA branch can also be created and switched to in one command:
git switch -c login-featuremain
|
+-- login-feature
| |
| +-- LoginTest.java
| +-- LoginPage.java
|
+-- search-feature
|
+-- SearchTest.java
+-- SearchPage.java
This allows different automation features to be developed independently.
The primary branch is commonly named main. It is often used as the stable integration branch of a project.
A common workflow is to create feature branches from main, develop and test changes there, and then propose those changes for integration into main.
The git merge command combines changes from one branch into another.
git switch main
git merge login-feature
Git's documentation describes merge as a command for combining lines of development, such as bringing work from a feature branch into another branch. :contentReference[oaicite:8]{index=8}
A merge conflict occurs when Git cannot automatically determine how to combine changes from different lines of development.
Developer A
|
+-- LoginTest.java
|
v
Feature Branch
Developer B
|
+-- LoginTest.java
|
v
Main Branch
|
v
Merge
|
v
Possible Conflict
When a conflict occurs, the developer must inspect the conflicting file, decide which changes should remain, remove the conflict markers, and create an appropriate commit.
A conflicted file may contain markers similar to:
<<<<<<< HEAD
Current branch changes
=======
Incoming branch changes
>>>>>>> feature-login
The developer resolves the content and removes the conflict markers before staging the resolved file.
A remote repository is another copy of a Git repository accessible through a remote URL. A GitHub repository is a common remote repository used for team collaboration.
A remote URL can use HTTPS or SSH, and Git commonly names the default remote origin. :contentReference[oaicite:9]{index=9}
To view configured remotes:
git remote -vExample:
origin https://github.com/user/selenium-project.git (fetch)
origin https://github.com/user/selenium-project.git (push)
After creating a GitHub repository, connect the local Git repository to it using:
git remote add origin https://github.com/YOUR-USERNAME/YOUR-REPOSITORY-NAME.gitThen verify:
git remote -vGitHub documents git remote add origin as a way to associate a remote URL with the name origin. :contentReference[oaicite:10]{index=10}
The git clone command creates a local copy of an existing remote repository.
git clone https://github.com/user/selenium-project.gitThe cloned repository contains the project files and Git history available from the remote repository. :contentReference[oaicite:11]{index=11}
GitHub Repository
|
| git clone
v
Local Repository
|
v
Working Directory
The git push command sends local commits to a remote repository.
git pushFor a newly created branch, you may establish its upstream remote branch using:
git push -u origin feature-loginGitHub documents git push as the command used to update a remote repository with commits made locally. :contentReference[oaicite:12]{index=12}
The git pull command obtains changes from the corresponding remote branch and integrates them into the current local line of development.
git pullIt is commonly used before starting new work when teammates may have published updates to the remote repository.
The git fetch command retrieves information and updates from a remote repository without directly integrating those changes into the current working branch.
git fetch originThis can be useful when you want to inspect remote changes before deciding how to integrate them.
| git fetch | git pull |
|---|---|
| Downloads remote updates | Downloads and integrates remote updates |
| Does not directly update the current branch | Updates the current local branch |
| Useful for inspecting remote changes | Useful for synchronizing local work |
A GitHub repository is a remotely hosted project repository. It can contain source code, documentation, configuration files, test automation scripts, issues, and other project resources.
A Selenium automation repository may contain:
selenium-framework/
|
|-- src/
| |-- test/
| |-- main/
|
|-- pom.xml
|-- testng.xml
|-- README.md
|-- .gitignore
|-- config.properties
A README.md file documents the project. It commonly explains what the project does, how to install it, how to execute tests, required tools, project structure, and other useful information.
# Selenium Automation Framework
## Overview
Selenium TestNG automation framework.
## Requirements
- Java
- Maven
- Selenium
- TestNG
## Execution
mvn test
The .gitignore file specifies files and directories that Git should ignore.
A Selenium project may ignore generated reports, compiled files, IDE metadata, temporary files, and local configuration containing sensitive information.
target/
*.log
.idea/
.classpath
.project
test-output/
*.tmp
Using .gitignore helps prevent unnecessary generated files from entering the repository.
GitHub displays commits that have been pushed to the remote repository. Commit history helps developers understand how a project changed over time.
Commit History
Add checkout tests
|
Fix payment locator
|
Add payment page
|
Add login test
|
Initial framework
GitHub supports remote branches that correspond to branches in Git repositories. Teams can use branches to isolate features, fixes, experiments, or release work.
main
|
+-- feature-login
|
+-- feature-search
|
+-- bugfix-payment
|
+-- release-v1
A Pull Request (PR) is a GitHub collaboration mechanism used to propose changes from one branch to another. Team members can review the proposed changes, discuss them, and merge them when the project's workflow requirements are satisfied. :contentReference[oaicite:13]{index=13}
feature-login
|
| Pull Request
v
main
Create Feature Branch
|
v
Write Code
|
v
Run Selenium Tests
|
v
git add
|
v
git commit
|
v
git push
|
v
Create Pull Request
|
v
Code Review
|
v
Merge
Code review is the process of examining proposed code changes before they are integrated into another branch.
In a Selenium project, reviewers may check:
GitHub Issues can be used to track bugs, tasks, enhancements, and other project discussions.
Git tags can identify specific points in repository history, commonly for releases or important versions.
git tag v1.0
git tag v1.1
Tags can help teams identify stable framework or application versions.
The git stash command temporarily saves local modifications so you can work on another branch or perform another Git operation without committing unfinished work.
git stashTo restore the most recently stashed changes:
git stash popWorking on Login Feature
|
v
Urgent Bug Fix Required
|
v
git stash
|
v
Switch to Bugfix Branch
|
v
Fix Bug
|
v
Return to Login Feature
|
v
git stash pop
The git reset command can move the current branch reference and, depending on the mode, alter staging and working-tree state. It should be used carefully because some forms can discard work.
git reset HEAD~1Before using reset on shared branches, understand exactly which history and working-tree changes the selected mode will produce.
The git revert command creates a new commit that reverses the effect of an earlier commit.
git revert <commit-id>Revert is often useful when a change has already been shared with others and you want to undo its effect without rewriting the existing shared history.
| Reset | Revert |
|---|---|
| Moves branch history | Creates a new reversing commit |
| Can change commit history | Preserves existing commits |
| Use carefully on shared branches | Often suitable for undoing shared changes |
git checkout is an older, widely used Git command that can switch branches and perform other operations. Modern Git provides more specialized commands such as git switch for branch switching and git restore for restoring files.
git checkout feature-loginThe git restore command can restore files to a previous state or remove changes from the working tree or staging area depending on how it is used.
git restore LoginTest.javaAlways review the intended effect before restoring uncommitted work.
Local Working Directory
|
v
git add
|
v
git commit
|
v
Local Branch
|
v
git push
|
v
GitHub Remote Branch
A common Git workflow for a new automation project is:
1. Create project
2. git init
3. Create files
4. git status
5. git add .
6. git commit -m "Initial framework"
7. Create GitHub repository
8. git remote add origin <REMOTE_URL>
9. git push -u origin main
Create Selenium Framework
|
v
git init
|
v
Create Tests
|
v
git status
|
v
git add .
|
v
git commit
|
v
Create Branch
|
v
Develop Feature
|
v
Run Selenium Tests
|
v
git push
|
v
Pull Request
|
v
Code Review
|
v
Merge
A typical Selenium Maven project may contain:
selenium-framework/
|
|-- src/
| |-- main/
| | |-- java/
| | |-- pages/
| | |-- utilities/
| |
| |-- test/
| |-- java/
| |-- tests/
|
|-- pom.xml
|-- testng.xml
|-- README.md
|-- .gitignore
Git can track the source files and project configuration while generated output such as Maven's target/ directory can normally be excluded through .gitignore.
Git is especially useful when a Selenium framework uses Page Object Model because page classes, test classes, utilities, and configuration files are often developed independently.
Git Repository
|
+-- pages
| +-- LoginPage.java
| +-- SearchPage.java
|
+-- tests
| +-- LoginTest.java
| +-- SearchTest.java
|
+-- utilities
+-- DriverFactory.java
+-- ConfigReader.java
A simple automation team can use branches such as:
main
|
+-- feature/login-tests
+-- feature/search-tests
+-- feature/checkout-tests
+-- bugfix/login-locator
+-- feature/reporting
Each branch can contain focused changes before being reviewed and merged.
Test reports generated by Selenium/TestNG should be handled carefully. Source code and framework configuration generally belong in version control, while generated report directories may be excluded depending on the team's reporting and CI/CD strategy.
target/
test-output/
reports/
*.log
Teams may choose a different strategy if reports are intentionally published or retained as build artifacts.
Test data can be maintained in CSV, JSON, Excel, database, or configuration files. Not every data file should automatically be committed to Git.
Credentials, tokens, private keys, and other secrets should not normally be stored as plain text in a public or shared source repository.
Framework
|
+-- Source Code
|
+-- Non-sensitive Test Data
|
+-- Configuration Templates
|
+-- Secure Runtime Secrets
Git repositories are commonly used as the source for CI/CD pipelines. A pipeline can detect repository changes, build the project, execute automated tests, and publish results.
Developer
|
v
git push
|
v
GitHub
|
v
CI/CD Pipeline
|
+-- Build
|
+-- Selenium Tests
|
+-- Test Reports
|
v
Build Result
GitHub Actions is a GitHub automation platform that can be used to build workflows around repository events. A Selenium project can use a workflow to install dependencies, execute Maven tests, and publish or retain test results according to the project's configuration.
Git Push
|
v
GitHub Actions
|
v
Checkout Repository
|
v
Setup Java
|
v
Run Maven Tests
|
v
Selenium Execution
|
v
Test Report
name: Selenium Tests
on:
push:
pull_request:
jobs:
test:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Set up Java
uses: actions/setup-java@v4
with:
distribution: temurin
java-version: '17'
- name: Run Tests
run: mvn test
The exact workflow should be adjusted to the project's Java version, browser strategy, Selenium setup, test runner, and reporting requirements.
A fork is a separate repository copy under another GitHub account or organization. Forks are commonly used when contributing to repositories where direct write access is not available.
Original Repository
|
v
Fork
|
v
Personal Repository
|
v
Feature Branch
|
v
Pull Request
|
v
Original Repository
Repository
|
v
Clone
|
v
Create Branch
|
v
Modify Code
|
v
Commit
|
v
Push
|
v
Pull Request
|
v
Review
|
v
Merge
This branch-and-pull-request workflow is a common way to collaborate on GitHub projects. :contentReference[oaicite:14]{index=14}
GitHub repositories can use access controls to determine who can view, modify, review, or manage project resources. Teams should grant only the access appropriate for the project's collaboration requirements.
For automation projects, repository permissions are important because test code may contain application URLs, configuration, test data, or internal implementation details.
Tags can identify specific versions of a Selenium framework or project.
git tag v1.0.0
git push origin v1.0.0
For example:
v1.0.0
|
+-- Initial Selenium Framework
v1.1.0
|
+-- Added Data Providers
v1.2.0
|
+-- Added Reporting
Git history can help identify when a Selenium test, locator, configuration, or utility changed.
git log --oneline -- LoginTest.javaThis can help an engineer investigate whether a failure appeared after a particular code change.
Git provides several ways to compare current and historical versions of files.
git diff
git diff --staged
git diff HEAD
git diff main..feature-login
These commands can help review modifications before committing or merging.
| Command | Purpose |
|---|---|
| git --version | Displays Git version |
| git config | Configures Git settings |
| git init | Initializes repository |
| git clone | Copies a remote repository locally |
| git status | Shows repository status |
| git add | Stages changes |
| git commit | Creates a commit |
| git log | Shows commit history |
| git diff | Shows changes |
| git branch | Lists or manages branches |
| git switch | Switches branches |
| git merge | Combines branches |
| git remote | Manages remote repositories |
| git fetch | Retrieves remote updates |
| git pull | Retrieves and integrates remote changes |
| git push | Publishes local commits to remote |
| git stash | Temporarily stores uncommitted changes |
| git revert | Creates a commit that reverses another commit |
| git tag | Creates version tags |
These commands cover the core workflow documented by GitHub for working with Git repositories. :contentReference[oaicite:15]{index=15}
Suppose a QA automation engineer is developing a Selenium login feature.
Step 1:
Clone Repository
Step 2:
Create Branch
feature/login
Step 3:
Create LoginPage.java
Step 4:
Create LoginTest.java
Step 5:
Run Selenium Tests
Step 6:
git status
Step 7:
git add .
Step 8:
git commit -m "Add login automation"
Step 9:
git push -u origin feature/login
Step 10:
Create Pull Request
Step 11:
Code Review
Step 12:
Merge into main
selenium-automation/
|
|-- src/
| |
| |-- main/
| | |
| | +-- java/
| | |
| | +-- pages/
| | | +-- LoginPage.java
| | | +-- SearchPage.java
| | |
| | +-- utilities/
| | +-- DriverFactory.java
| | +-- ConfigReader.java
| |
| +-- test/
| |
| +-- java/
| |
| +-- tests/
| +-- LoginTest.java
| +-- SearchTest.java
|
|-- pom.xml
|-- testng.xml
|-- README.md
|-- .gitignore
GitHub
|
Remote Repository
|
+-----+-----+
| |
main branches
| |
| feature branches
| |
+-----+-----+
|
Pull Request
|
Code Review
|
Merge
|
main branch
|
CI/CD
|
Selenium Automation
|
Test Reports
| Stage | Typical Activity |
|---|---|
| 1 | Clone or update repository |
| 2 | Create feature or bug-fix branch |
| 3 | Develop Selenium automation |
| 4 | Run tests locally |
| 5 | Review Git changes |
| 6 | Commit changes |
| 7 | Push branch |
| 8 | Create pull request |
| 9 | Review and address feedback |
| 10 | Merge after project checks are satisfied |
| 11 | CI/CD executes automated validation |
Git is a distributed version control system used to track changes and maintain project history.
GitHub is a platform for hosting Git repositories and providing collaboration features around Git.
Git is the version control system, while GitHub is a platform that hosts Git repositories and provides collaboration capabilities.
A Git repository is a project directory managed by Git that contains files and version-control history.
It initializes a Git repository in a directory.
It creates a local copy of an existing remote repository.
It stages changes for the next commit.
It records staged changes as a snapshot in the local repository history.
It publishes local commits to a remote repository.
It obtains changes from a remote repository and integrates them into the current local branch.
A branch is an independent line of development used to isolate changes.
Merge combines changes from different branches.
A merge conflict occurs when Git cannot automatically combine conflicting changes.
A pull request proposes changes from one branch to another for review and integration.
.gitignore specifies files and directories that Git should normally ignore.
It displays the state of the working directory and staging area.
It displays commit history.
It temporarily stores uncommitted changes so work can be switched without committing unfinished changes.
Git helps Selenium teams manage automation code, framework changes, branches, collaboration, history, and CI/CD integration.
Secrets such as passwords, tokens, and private keys can expose sensitive access if they are stored in source control.
git --version.git init..gitignore file.git add.git init.git status.git add.git commit.git log and git diff.| Concept | Meaning |
|---|---|
| Git | Distributed version control system |
| GitHub | Platform for hosting and collaborating on Git repositories |
| Repository | Project managed by Git |
| Working Directory | Current project files being edited |
| Staging Area | Changes selected for the next commit |
| Commit | Snapshot of staged changes |
| Branch | Independent line of development |
| Merge | Combines branches |
| Remote | Remote repository location |
| Origin | Common name for the default remote |
| Clone | Copies a remote repository locally |
| Push | Sends local commits to remote |
| Pull | Gets and integrates remote changes |
| Fetch | Gets remote updates without directly integrating them into the current branch |
| Pull Request | Proposal to integrate branch changes |
| .gitignore | Specifies files Git should ignore |
| Tag | Identifies a specific point in repository history |
Git is a distributed version control system that helps developers and testers track project changes, maintain history, create branches, compare modifications, merge work, and restore previous versions when required.
GitHub provides remote repository hosting and collaboration capabilities around Git. It supports workflows involving branches, pull requests, code review, issues, and repository management. :contentReference[oaicite:16]{index=16}
For Selenium automation engineers, Git and GitHub are essential tools for managing automation frameworks, Page Object classes, test cases, utilities, configuration files, test data, Maven projects, and CI/CD workflows.
A typical Selenium Git workflow is:
Clone / Init
|
v
Create Branch
|
v
Write Selenium Code
|
v
Run Tests
|
v
git add
|
v
git commit
|
v
git push
|
v
Pull Request
|
v
Code Review
|
v
Merge
|
v
CI/CD
|
v
Test Reports
Learn more about Selenium automation and related testing concepts:
Final Takeaway: Git manages version history and collaboration at the source-control level, while GitHub provides a platform for hosting repositories and collaborating around them. For a Selenium automation engineer, knowing Git, branches, commits, pull requests, conflict resolution, and GitHub workflows is an important part of working effectively in a professional automation team.
